Although information technology must deal with fast paced advances, it must still deal with legacy applications and data that have been inherited from languages, platforms, and techniques originated in an earlier computer era. Most enterprises which use computers have legacy applications and databases that continue to serve critical business needs. A primary example of such legacy applications are found on mainframe host computers, such as International Business Machines (IBM) model 390 mainframe computers and accessed by asynchronous text-based terminals.
A large portion of the computer user community no longer use asynchronous text-based terminals, but rather use graphical user interface (GUI) based personal computers (PCs). Some of these GUI based PCs run text-based terminal emulation programs to access the mainframe host computers. A disadvantage of the text-based terminal emulation programs is that the text-based screens furnished are not as user-friendly as a GUI based display. To address this and other issues some have turned to accessing mainframe host computers through intermediary server computers.
The GUI based PCs form network connections with the server computers and in turn the server computers form network connections with the mainframe host computers. Oftentimes these server computers run screen scraping programs that translate between legacy application programs (written to communicate with now generally obsolete input/output devices and user interfaces) and newer user GUI interfaces so that the logic and data associated with the legacy programs can continue to be used. Screen scraping is sometimes called advanced terminal emulation.
For example, a program that does screen scraping must take the data coming from the legacy program running on a mainframe host computer that is formatted for the screen of a text-based terminal such as an IBM 3270 display or a Digital Equipment Corporation VT100 and reformat it for a Microsoft Windows GUI or a PC based Web browser. The program must also reformat user input from the newer user interfaces (such as a Windows GUI or a Web browser) so that the request can be handled by the legacy application as if it came from a user of the older device and user interface.
First generation advanced terminal emulation systems involve automated conversion of a collection of host terminal screens into a corresponding collection of GUI screens using such presentation languages as HyperText Markup Language (HTML), or languages based on Microsoft Windows GUI or Sun Systems Java GUI.
These first generation systems follow rigid rules for conversion of host screen based data to a GUI format. For example, a conversion of a host screen into a GUI based on HTML would typically include such mandatory conversion operations as all host screen fields having a protected status being converted to an HTML text that was static in nature, all unprotected host screen fields being converted to HTML input boxes and certain keywords on the host screen such as “PF1”, “PF2”, etc. being converted to GUI based buttons. The first generation systems fall short in addressing many needs in presenting and processing data of the legacy host systems as well as other systems due to the lack of flexibility, among other things, of the first generation systems. Legacy host systems include systems from International Business Machines, Sperry-Univac, Wang, Digital Equipment Corporation, Hewlett Packard, and others.
To address this lack of facility of the first generation systems, second generation advanced terminal emulation systems allow a certain degree of customization of the conversion process and resulting GUIs. The customization process, however, is very manually intensive. Typically applications are written in a preferred environment such as Visual Basic, PowerBuilder, Visual C++ and Delphi by associating a set of controls provided by the second generation system to a recording of session screens of a host system. Many of the controls are tightly coupled to particular fields of the host screens.
As an unfortunate consequence, GUI developers using first and second generation systems must spend a great deal of time becoming familiar with the terminal screens of legacy host systems. Other time is spent in manually relating various aspects of the host terminal screens with the resultant GUIs. Also, since the resultant GUIs of the first and second generation systems are still backwardly focused on the host terminal screens, integration of data from other systems not involving terminal screens and generation of presentation systems not involving GUIs may be difficult if not impossible for the first and second generation systems to accomplish.
Regarding presentation systems not involving GUIs, another trend in the computer user community is to use communication devices and other processing devices that directly or indirectly communicate with computer systems such as legacy host systems. Many of these devices tend to be portable and tend to communicate over wireless means. Oftentimes these devices are not GUI based, but since they are also not based upon a legacy terminal screen, issues arise that are similar with those discussed above with respect to generating applications to work with legacy host systems and other data providing systems. With regard to generation and operation of both GUI and non-GUI applications, it would be desirable to improve upon the shortcomings experienced with regard to the first and second generation systems discussed above.